// 2025.03.21 15:35 星期五 晴 昨天 说我太特别 你是个什么东西?
// 这个是 对 元素 消失 及 展现

import { global_delay_appear } from '../../../DataDefine/sourceData';
import {
  endsTimeAnimation,
  settimeNth,
  toStringTypeCheck,
} from '../../../Func/uniFunc/Func';
import { remove_class } from '../../class_operate/Func';
import { create_staticCssTxt_mana } from '../../css/setStaticCsstxt';
import { css_disnone } from '../../DataDefine/sourceData';
import { appearEl_mana } from './Classes/cla_appearEl_mana';
import { disappearEl_mana } from './Classes/cla_disappearEl_mana';
import {
  staticCss_prefix_appear,
  staticCss_prefix_disappear,
} from './DataDefine/sourceData';

// eslint-disable-next-line no-unused-vars
import { appear_Direct } from './DataDefine/sourceData';

/**
 * static css 管理
 * appear
 */
const StaticCss_appear = create_staticCssTxt_mana('appearDom');

/**
 * static css 管理
 * disappear
 */
const StaticCss_disappear = create_staticCssTxt_mana('disappearDom');

/**
 * 显示 元素
 * @param {HTMLElement | HTMLElement[]} elt
 * @param {appear_Direct} direct default -- both
 * @param {Function} afterCb 最后执行 的 函数
 */
function appearElFunc(elt, direct = 'both', afterCb) {
  if (toStringTypeCheck(elt, 'array')) {
    for (const uni_elt of elt) {
      appearElFunc(uni_elt, direct, afterCb);
    }
    return;
  }

  let appearObj = new appearEl_mana(elt, direct);
  // 创建 对应消失 方向的 css
  StaticCss_appear.setStaticCssTxt(
    staticCss_prefix_appear + elt.id,
    appearObj.setstaticCss(),
    true
  );

  let { targetEl: element, appearEl_anima_cla } = appearObj;

  // // 装载 消失 元素 到 当前元素 位置
  // packNode(parentEl, disEl, true, nextEl);

  // // 将当前元素 装载到 消失元素 中
  // packNode(disEl, element);

  // 应用动画
  // requestAnimationFrame(() => {
  // 在 动画 结束后 隐藏元素
  let delay = endsTimeAnimation(element, appearEl_anima_cla);

  /**
   * 逻辑修订
   * 这种操作 会影响到 uni_child_func
   */
  // // 在 动画 执行 后一帧 再 移除 disnone
  // requestAnimationFrame(() => {
  //   remove_class(element, 'disnone');
  // });

  settimeNth(delay, () => {
    // // 放回原来位置
    // packNode(parentEl, element, true, disEl);

    // disEl.remove();

    if (afterCb instanceof Function) {
      afterCb();
    }
  });
  // });
}

/**
 * 隐藏 元素
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct default -- both
 * @param {Function} afterCb 最后执行 的 函数
 */
function disappearElFunc(elt, direct = 'both', afterCb) {
  if (toStringTypeCheck(elt, 'array')) {
    for (const uni_elt of elt) {
      disappearElFunc(uni_elt, direct, afterCb);
    }
    return;
  }

  let disappearObj = new disappearEl_mana(elt, direct, afterCb);

  // 创建 对应消失 方向的 css
  StaticCss_disappear.setStaticCssTxt(
    staticCss_prefix_disappear + elt.id,
    disappearObj.setstaticCss(),
    true
  );

  let { targetEl: element, disappearEl_anima_cla } = disappearObj;

  // // 装载 消失 元素 到 当前元素 位置
  // packNode(parentEl, disEl, true, nextEl);

  // // 将当前元素 装载到 消失元素 中
  // packNode(disEl, element);

  // 应用动画
  // requestAnimationFrame(() => {
  let delay = endsTimeAnimation(element, disappearEl_anima_cla);

  settimeNth(delay - global_delay_appear, () => {
    // 在 动画 结束后 隐藏元素
    // add_class(element, 'disnone');

    // // 放回原来位置
    // packNode(parentEl, element, true, disEl);

    // disEl.remove();

    if (afterCb instanceof Function) {
      afterCb();
    }
  });
  // });
}

/**
 * 对 元素 旗下 子元素 也进行 显示放大
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct
 * @param {function} afterCb
 */
function appearEl_child_func(elt, direct, afterCb) {
  let promise_arr = [];

  /**
   *
   * @param {HTMLElement} element
   */
  let deep_children_func = (element) => {
    let uni_child_func = new Promise((res) => {
      appearElFunc(element, direct, () => {
        res();
      });
    });
    // console.log(element);
    promise_arr.push(uni_child_func);
    for (const cur_chi_node of element.children) {
      deep_children_func(cur_chi_node);
    }
  };

  deep_children_func(elt);

  Promise.all(promise_arr).then(afterCb);
}

/**
 * 对 元素 旗下 子元素 也进行 显示缩小
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct
 * @param {function} afterCb
 */
function disappearEl_child_func(elt, direct, afterCb) {
  let promise_arr = [];

  /**
   *
   * @param {HTMLElement} element
   */
  let deep_children_func = (element) => {
    let uni_child_func = new Promise((res) => {
      disappearElFunc(element, direct, () => {
        res();
      });
    });
    // console.log(element);
    promise_arr.push(uni_child_func);
    for (const cur_chi_node of element.children) {
      deep_children_func(cur_chi_node);
    }
  };

  deep_children_func(elt);

  Promise.all(promise_arr).then(afterCb);
}

/**
 * 只 执行 显示动画 并 返回 promise 完成 时态
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct
 */
function appearElFunc_promise(elt, direct) {
  let p = new Promise((res) => {
    appearElFunc(elt, direct, res);
    /**
     * 逻辑修订
     * 在 元素 显示动画 会 出现 闪现 问题
     */
    remove_class(elt, css_disnone, true);

    settimeNth(global_delay_appear, () => {
      remove_class(elt, css_disnone);
    });
  });

  return p;
}

/**
 * 只 执行 消失动画 并 返回 promise 完成时态
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct
 * @returns
 */
function disappearElFunc_promise(elt, direct) {
  let p = new Promise((res) => {
    disappearElFunc(elt, direct, res);
  });

  return p;
}

/**
 * 应用 当前 元素 及其 所有 子节点 显示动画 并 返回 promise 完成时态
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct default = 'both'
 * @returns
 */
function appearEl_child_func_promise(elt, direct) {
  let p = new Promise((res) => {
    appearEl_child_func(elt, direct, res);

    /**
     * 逻辑修订
     * 在 元素 显示动画 会 出现 闪现 问题
     */
    remove_class(elt, css_disnone, true);

    settimeNth(global_delay_appear, () => {
      remove_class(elt, css_disnone);
    });
  });

  return p;
}

/**
 * 应用 当前 元素 及其 所有 子节点 消失动画 并 返回 promise 完成时态
 * @param {HTMLElement} elt
 * @param {appear_Direct} direct
 * @returns
 */
function disappearEl_child_func_promise(elt, direct) {
  let p = new Promise((res) => {
    disappearEl_child_func(elt, direct, res);
  });

  return p;
}

export {
  appearElFunc,
  disappearElFunc,
  appearEl_child_func,
  disappearEl_child_func,
  appearElFunc_promise,
  disappearElFunc_promise,
  appearEl_child_func_promise,
  disappearEl_child_func_promise,
};
